(defn composite-perf2 []
  (let [tests [[true [-1]]
               [true [-1 1 2]]
               [false [-1 0 2]]
               [false [-1 -1 -1 -1]]]
        assert! (fn [f]
                  (doseq [[expected data] tests]
                    (assert (= expected (f data)))))]

    ;; 155ns
    (let [valid? (fn [x]
                   (and (vector? x)
                        (<= (count x) 3)
                        (every? #(and (int? %) (or (pos-int? %) (neg-int? %))) x)))]
      (assert! valid?)
      (cc/quick-bench
        (valid? [-1 1 2])))

    ;; 27ns
    (let [valid? (m/validator
                   [:vector {:max 3}
                    [:and int? [:or pos-int? neg-int?]]])]
      (assert! valid?)
      (cc/quick-bench
        (valid? [-1 1 2])))

    ;; 506ns
    (let [spec (s/coll-of
                 (s/and int? (s/or :pos-int pos-int? :neg-int neg-int?))
                 :kind vector?
                 :max-count 3)
          valid? (partial s/valid? spec)]
      (assert! valid?)
      (cc/quick-bench
        (valid? [-1 1 2])))))

Error building classpath. Unable to compare versions for borkdude/edamame: {:mvn/version "0.0.5-SNAPSHOT", :deps/manifest :mvn} and {:git/url "", :sha "b577e565b136d3dd51945fe874049d4297946f57", :deps/manifest :deps, :deps/root "/Users/beders/.gitlibs/libs/borkdude/edamame/b577e565b136d3dd51945fe874049d4297946f57"}

clj -Sdeps '{:deps {metosin/malli {:git/url "" :sha "10b09bef72a52755764ba21933edc983fc4135e7"}, borkdude/edamame {:git/url "", :sha "d7d0f12c336dc513702c8c704b147223f85e377f"}}}'

clj -Sdeps '{:deps {metosin/malli {:git/url "" :sha "22122b2ff9434bfd0db8d72fcd06cb48914c6eb4"}}}'

(require '[malli.core :as m])
(require '[malli.transform :as mt])

(def Pizza
  [:map
   [:id int?]
   [:name string?]
   [:created inst?]])

(def json->Pizza
  (m/transformer
    Pizza
    mt/json-transformer))


(json->Pizza
  {:id 1
   :name "salami"
   :created "2019-10-04T09:08:36.078Z"})
;{:id 1
; :name "salami"
; :created #inst"2019-10-04T09:08:36.078-00:00"}

(require '[criterium.core :as cc])

(cc/quick-bench
  (json->Pizza
    {:id 1
     :name "salami"
     :created "2019-10-04T09:08:36.078Z"}))
; Evaluation count : 386256 in 6 samples of 64376 calls.
;              Execution time mean : 1.719360 µs
;     Execution time std-deviation : 100.090402 ns
;    Execution time lower quantile : 1.601860 µs ( 2.5%)
;    Execution time upper quantile : 1.811632 µs (97.5%)
;                    Overhead used : 1.862824 ns

(require '[schema.core :as s])
(require '[schema-tools.coerce :as stc])

(def json->Pizza2
  (stc/coercer {:id s/Int, :name s/Str, :created s/Inst} stc/json-coercion-matcher))

(json->Pizza2
  {:id 1
   :name "salami"
   :created "2019-10-04T09:08:36.078Z"})
;{:id 1
; :name "salami"
; :created #inst"2019-10-04T09:08:36.078-00:00"}

(cc/quick-bench
  (json->Pizza2
    {:id 1
     :name "salami"
     :created "2019-10-04T09:08:36.078Z"}))
; Evaluation count : 261396 in 6 samples of 43566 calls.
;              Execution time mean : 2.352737 µs
;     Execution time std-deviation : 173.369968 ns
;    Execution time lower quantile : 2.255370 µs ( 2.5%)
;    Execution time upper quantile : 2.636725 µs (97.5%)
;                    Overhead used : 1.600826 ns

[:and string? [:fn {:error/message "should not be empty"} 'not-empty]]

(defmacro x [y]
  `(println ~(m/schema [:tuple y])))

Syntax error compiling fn* at (/private/var/folders/fm/5mzhclpd7mj0tzjjq796ftc00000gn/T/form-init14721255528686671623.clj:1:1).
Can't embed object in code, maybe print-dup not defined: 

(defmacro x [y]
  `(println (m/schema [:tuple ~y])))
=> #'clj-rest-client.core/x
(x int?)
[:tuple int?]

(m/explain [:tuple] [])
Execution error (NullPointerException) at malli.core/-tuple-schema$reify$reify$fn (core.cljc:447).
null

(require '[malli.core :as m])

(def sequential (#'m/-collection-schema `sequential sequential? seq nil))

(m/validate [sequential int?] '(1 2 3)) 
; => true

(m/validate [sequential int?] [1 2 3]) 
; => true

(m/form [sequential int?])
; => [user/sequential int?]

(let [schema (-> [:and {:title "lower-upper-string"
                        :decode/string '(constantly str/upper-case)
                        :encode/string '(constantly str/lower-case)}
                  string?]
                 (malli.edn/write-string)
                 (malli.edn/read-string))]
  (as-> "kikka" $
        (m/decode schema $ mt/string-transformer)
        (doto $ prn)
        (m/encode schema $ mt/string-transformer)
        (doto $ prn)
        schema))
; prints "KIKKA"
; prints "kikka"
; => [:and
;     {:title "lower-upper-string"
;      :decode/string (constantly str/upper-case)
;      :encode/string (constantly str/lower-case)}
;      string?]

error in process sentinel: Could not start nREPL server: Error building classpath. Unable to compare versions for borkdude/edamame: {:mvn/version "0.0.8-alpha.4", :deps/manifest :mvn} and {:git/url "", :sha "34755e7a875fae2ab4d64e6be89b6270046a91a3", :deps/manifest :deps, :deps/root "/Users/xxx/.gitlibs/libs/borkdude/edamame/34755e7a875fae2ab4d64e6be89b6270046a91a3"}

➜  ~ clj -Sdeps '{:deps {metosin/malli {:git/url ""
                                        :sha "e2ff736ff923c676de655b853180be2503715d88"}}}'
Checking out:  at e2ff736ff923c676de655b853180be2503715d88
Clojure 1.10.1
user=>

[:json-schema 
  {:type "object"
   :properties {:name {:type "string"}
                :number {:type "number"}
   :required [:name]}]

(def date-time (reify IntoSchema ...))

(m/validate date-time (java.time.DateTime.))
; => true

(defprotocol IntoSchema
  (-into-schema [this properties children opts] "creates a new schema instance"))

(require '[malli.core :as m])
(require '[malli.edn :as edn])

(-> [:and
     [:map
      [:x int?]
      [:y int?]]
     [:fn '(fn [{:keys [x y]}] (> x y))]]
    (edn/write-string)
    (doto prn) ; => "[:and [:map [:x int?] [:y int?]] [:fn (fn [{:keys [x y]}] (> x y))]]"
    (edn/read-string)
    (doto (-> (m/validate {:x 0, :y 1}) prn)) ; => false
    (doto (-> (m/validate {:x 2, :y 1}) prn))) ; => true
;[:and 
; [:map 
;  [:x int?] 
;  [:y int?]] 
; [:fn (fn [{:keys [x y]}] (> x y))]]

(m/defn plus :- int? 
  [x :- int?, y :- int?] 
  (+ x y))

(require '[malli.evil :as evil])

(evil/register! ::int int?)

(evil/validate ::int 1)
; => true

(m/decode 
  [:map {:decode/my-thing (fn [schema opts] ...do...thing...)} [:a int?] [:b int?]]
  {"a_kikka" 12, "b_kikka" 32}
  (mt/transformer {:name :my-thing))

(m/decode
  [:multi {:dispatch :type
           :decode/string '(constantly #(update % :type keyword))}
   [:sized [:map [:type [:= :sized] [:size int?]]]
   [:human [:map [:type [:= :human]] [:name string?] [:address [:map [:country keyword?]]]]]]
  {:type "human"
   :name "Tiina"
   :age "98"
   :address {:country "finland"
             :street "this is an extra key"}}
  (mt/transformer mt/strip-extra-keys-transformer mt/string-transformer))
;{:type :human
; :name "Tiina"
; :address {:country :finland}}

(is (= {:x_key "true", :y 1} (m/decode schema {:x true :y "1"}
                                             (transform/transformer
                                              {:name :custom
                                               :decoders
                                               {:map
                                                (constantly (fn [map]
                                                              (if-not (contains? map :x)
                                                                map
                                                                (-> map
                                                                    (assoc :x_key (:x map))
                                                                    (dissoc :x)))))
                                                'boolean? (constantly str)}}))))

(defn- ->interceptor
  "Utility function to convert a transformer into an interceptor. Works with transformers
  that are already interceptors, as well as sequences of transformers"
  [transformer]
  (cond
   (fn? transformer) {:enter transformer :exit nil}
   (and (map? transformer)
        (or (contains? transformer :enter)
            (contains? transformer :exit))) transformer

   (coll? transformer) (reduce
                        (fn [{:keys [enter exit]} {new-enter :enter new-exit :exit}]
                          (let [enter (if (and enter new-enter)
                                        (comp enter new-enter)
                                        (or enter new-enter))
                                exit (if (and exit new-exit)
                                       (comp exit new-exit)
                                       (or exit new-exit))]
                            {:enter enter :exit exit}))
                        (map ->interceptor transformer))
   (nil? transformer) nil
   :else (throw (ex-info "Invalid transformer. Must be a function, sequence, or interceptor map"
                         {:value transformer}))))

(mt/transformer mt/json-transformer mt/json-transformer)

(mt/transformer {:decoders {:map keywordize-keys}} mt/strip-extra-keys-transformer)

(mt/transformer {:decoders {:map keywordize-keys}} {:decoders {:map upper-case-keys})

(>defn- wrap-vec
  "Wraps the given target into a vector. If its already in a sequence, it will
  be converted to a vector. If its a vector it will return itself. If its a value
  it will be inserted into a vector"
  [item]
  [any? => (s/coll-of any? :kind vector?)]
  (cond
   (vector? item) item
   (seq? item)    (into [] item)
   :else          [item]))

(m/defn plus :- int? 
  [x :- int?, y :- int?] 
  (+ x y))

(m/defn plus
  [x :- int?, y] 
  (+ x y))

(is (= [24 48 8 10]
       (m/decode
         [:tuple
          {:decode/string (constantly {:enter (partial mapv inc), :leave (partial mapv (partial * 2))})}
          [int? {:decode/string (constantly {:enter (partial + 2), :leave (partial * 3)})}]
          [int? {:decode/string (constantly {:enter (partial + 3), :leave (partial * 4)})}]]
         [1 2 3 4] mt/string-transformer)))

(m/decode
  [:and {:decode/enter (constantly inc), 
         :decode/string (constantly (partial * 2))
         :decode/leave (constantly (partial + 10))} int?]
  1
  (mt/transformer {:name :enter} mt/string-transformer {:name :leave}))
; => 30

(m/decode
  [:and {:decode/leave (constantly (partial + 10))} int?]
  "1"
  (mt/transformer {:name :enter} mt/string-transformer {:name :leave}))
; => 11

(m/decode
  [:and [int? {:decode/string '(constantly {:enter (partial + 2), :leave (partial * 3)})}]]
  "1"
  mt/string-transformer)

(->Coercer (m/decoder schema t)
           (m/encoder schema t)
           (m/validator schema)
           (m/explainer schema))

(m/encode [:sequential {:encode/string (constantly #(clojure.string/join "," %))}
           string?]
          ["A" "B" "C"]
          mt/string-transformer)
          
=> (\A \, \B \, \C)

(-transformer [this transformer context]
            (let [child-xf (m/-value-transformer transformer schema' context)]
              (if child-xf
                (if (= :decode context)
                  (comp child-xf xf)
                  (comp xf child-xf))
                xf)))

my enter logic
call child
my leave logic

(m/encode [:sequential {:encode/string (constantly {:leave #(clojure.string/join "," %)})}
           string?]
          ["A" "B" "C"]
          mt/string-transformer)
Error printing return value (NullPointerException) at clojure.core/map$fn (core.clj:2755).
null

(m/decode
  [string? {:decode/string '(constantly #(str "olipa_" %))}]
  "kerran" mt/string-transformer)
; => olipa_kerran

(m/decode
  [string? {:decode/string '(constantly {:enter #(str "olipa_" %)
                                         :leave #(str % "_avaruus")})}]
  "kerran" mt/string-transformer)
; => "olipa_kerran_avaruus"

(m/decode
  [:and
   {:decode/before '(constantly inc)
    :decode/after  '(constantly (partial * 2))}
   int?]
  1
  (mt/transformer {:name :before} {:name :after}))
; => 4

(m/decode
  [:and
   {:decode/before '(constantly {:enter inc
                                 :leave (partial * 2)})
    :decode/after  '(constantly {:enter (partial * 4)
                                 :leave inc})}
   int?]
  1
  (mt/transformer {:name :before} {:name :after}))
; => 18

(m/decode
  [:and
   {:decode/before '(constantly [inc inc #(* % 2) inc])}
   int?]
  1
  (mt/transformer {:name :before} {:name :after}))
; => 7

(m/decode
  [:and
   {:decode/after 'inc}
   int?]
  "1"
  (mt/transformer {:name :before} mt/string-transformer {:name :after}))
; => 2

;; mounts only if there :multiplier property in schema
(def multiply-interceptor
  {:name ::multiply
   :compile (fn [schema _]
              (if-let [multiplier (:multiplier (m/properties schema))]
                (partial * multiplier)))})

;; the interceptor does not mount as the `:multiplier` is missing:
(m/decode
  [:and
   {:decode/after multiply-interceptor}
   int?]
  "2"
  (mt/transformer {:name :before} mt/string-transformer {:name :after}))
; => 2

(m/decode
  [:and
   {:decode/after multiply-interceptor
    :multiplier 10}
   int?]
  "2"
  (mt/transformer {:name :before} mt/string-transformer {:name :after}))
; => 20

(def transformer (mt/transformer {:name :before} mt/string-transformer {:name :after}))

(m/decode 
  [:and 
   {:decode/after 'inc} 
   int?] 
  "1" 
  transformer)
; => 2

; :enter
;  :before
;  :strip-keys
;  :string => ->int "1" => 1
;  :after => inc 1 => 2
; :leave
;  :after
;  :string
;  :strip-keys
;  :before

(m/decode 
  [:and 
   {:decode/before {:leave 'inc}}
   int?]
  "1" 
  transformer)
; => 2

; :enter
;  :before
;  :strip-keys
;  :string => ->int "1" => 1
;  :after
; :leave
;  :after
;  :string
;  :strip-keys
;  :before => inc 1 => 2 

(m/decode
  [int? {:decode/before '(constantly {:leave inc})
         :decode/after '(constantly (partial * 2))}]
  "10"
  (mt/transformer
    {:name :before}
    mt/string-transformer
    {:decoders {'int? (constantly inc)}} ;; anonymous
    {:name :after}))
; => 23

;; :enter
;;  :string   "10" => 10
;;  anonymous   10 => 11
;;  :after      11 => 22
;; :leave
;;  :before     22 => 23

s/keys*

(m/encode
  [:map
   [:foo [:map
          [:foo int?]
          [:bar int?]]]
   [:bar int?]]
  {:foo {:foo 2 :bar 1} :bar 3}
  (transformer
    {:encoders {'int? (constantly inc)
                :map (constantly {:leave #(set/rename-keys % {:foo :oof :bar :rab})})}}))
; => {:oof {:oof 3, :rab 2}, :rab 4}

(m/encode
  [:map
   [:foo [:map
          [:foo int?]
          [:bar int?]]]
   [:bar int?]]
  {:foo {:foo 2 :bar 1} :bar 3}
  (transformer
    {:encoders {'int? inc
                :map {:leave #(set/rename-keys % {:foo :oof :bar :rab})}}}))
; => {:oof {:oof 3, :rab 2}, :rab 4}

(defn add-name-key
  [a]
  [:map => (+ a [:name string?])]
  (assoc a :name "Bob")

(defn fixed-length? [n]
  [:and 'string? [:fn `(~'fn [~'val] (~'= ~n (~'count ~'val)))]]
  )

(preds/fixed-length? 10)
=> [:and string? [:fn (fn [val] (= 10 (count val)))]]

(defn fixed-length? [n]
  [:and string? [:fn #(= n (count %)]])

(defn fixed-length? [n]
  [:and string? [:fn #(= n (count %))]])
=> #'sql-to-malli.integration/fixed-length?
(edn/write-string (fixed-length? 10))
=>
"[:and string? [:fn #object[sql_to_malli.integration$fixed_length_QMARK_$fn__10416 0x576cee60 \"

(defn fixed-length? [n]
  [:and 'string? [:fn `(fn [val] (= ~n (~'count val)))]]
  
  )
(fixed-length? 10)
=> [:and string? [:fn (clojure.core/fn [clojure.core/val] (clojure.core/= 10 (count clojure.core/val)))]]

(m/validate [:re #"^.{4}$"] "bubu")

(defn max-length?
  ([n s]
   (and (string? s) (< (count s) n)))
  )
(def default-registry (merge m/default-registry {:max-length (m/fn-schema :max-length preds/max-length?)}))

(m/validate [:max-length 4] "bubu" {:registry default-registry})

#error{:cause ":malli.core/child-error",
       :data {:type :malli.core/child-error, :data {:name :max-length, :properties nil, :children (4), :min 0, :max 0}},

[:map {:decode/string (fn [schema opts] 
                        (let [cool (:option (m/properties schema))]
                          (fn [value] …)))}]

[:map {:decode/string {:compile (fn [schema opts] 
                                  (let [cool (:option (m/properties schema))]
                                    (fn [value] …)))}}]

(decode [:map {:decode/row (fn [row]
                               {:name (nth row 0)
                                :age (nth row 1)})}
           [:name string?]
           [:age int?]]
          ["Bob" "42"]
          (malli.transform/transformer
           malli.transform/string-transformer
           {:name :row}))

[:select 
 [:map [:x int?] [:y int?]]
 [:x]]

(explain
  [:map {:closed true}
   [:xy
    [:map {:closed true}
     [:x int?]
     [:y int?]]]]
  {:xy {:x 1, :y 2, :EVIL "LYN"}
   :DARK "ORKO"})
;{:schema [:map {:closed true} [:xy [:map {:closed true} [:x int?] [:y int?]]]],
; :value {:xy {:x 1, :y 2, :EVIL "LYN"}, :DARK "ORKO"},
; :errors (#Error{:path [2 1],
;                 :in [:xy :EVIL],
;                 :schema [:map {:closed true} [:x int?] [:y int?]],
;                 :type :malli.core/extra-key}
;           #Error{:path [],
;                  :in [:DARK],
;                  :schema [:map {:closed true} [:xy [:map {:closed true} [:x int?] [:y int?]]]],
;                  :type :malli.core/extra-key})}

(-> [:map {:closed true} [:x int?]]
    (m/explain {:x 1, :extra "key"})
    (me/humanize))
; => {:extra ["disallowed key"]}

(defn closed-schema
  "Closes all :map Schemas recursively."
  [schema]
  (m/accept
    schema
    (m/schema-visitor
      (fn [schema]
        (if (= :map (m/name schema))
          (update-properties schema assoc :closed true)
          schema)))))

:math/multiplier

(mt/transformer
  mt/string-transformer
  mt/strip-extra-keys-transformer
  (mt/key-transformer
    {:decode #(-> % name (str "_key") keyword)
     :encode #(-> % name (str "_key"))}))

(mt/transformer
  (mt/string-transformer)
  (mt/strip-extra-keys-transformer)
  (mt/key-transformer
    {:decode #(-> % name (str "_key") keyword)
     :encode #(-> % name (str "_key"))}))

(-> (m/explain
      [:map {:closed true}
       [:orders boolean?]
       [:deliver boolean?]]
      {:orders true
       :deliverz true})
    (me/with-suggestions)
    (me/humanize))
;{:deliver ["missing required key"]
; :deliverz ["likely misspelling of :deliver"]}

(m/encode [:or
           [string? {:encode/string #(.toUpperCase %)}]
           [int? {:encode/string str}]]
          1
          mt/string-transformer)

Execution error (IllegalArgumentException) at com.github.roklenarcic.malli-inline/eval17000$fn (form-init15839185010501867114.clj:2).

No matching field found: toUpperCase for class java.lang.Long

(m/form [:and {} int?])
; => [:and int?]

(m/properties [:and {} int?])
; => {}

(m/form [:and {} int?])
; => [:and int?]
(m/properties [:and {} int?])
; => nil

(malli.util/merge 
  [:map [:x [:map [:y [:map [:z int?]] 
  (if require-z2 [:map [:x [:map [:y [:map [:z2 int?]]))

(-> {:a .. b:.. :c .. :d} ; say input from api call
     validate ; we only care about :a,:b and :c but ignore :d
     do-something-with-a-and-b ; fine with a s/keys [:a :b] or m/validate equivalent precondition
     do-something-with-c ; fine with a s/keys [:c]
     (select-keys [:a ::c]) ; or (transform my-schema)
     (write-a-b-c-to-datomic) ; at this point I want a closed schema/spec precond, that could potentially narrow the keys on the way in? 

(-> [:and
     [int? {:error/message "Not int"}]
     [:> 6 {:error/message "Less than 6"}]]
  (m/explain 6))

(-> [:and
     [int? {:error/message "Not int"}]
     [:> 6]]
  (m/explain "a"))

(malli.util/get-in
  [:map {:title "test"}
   [:x [:vector
        [:list
         [:set
          [:sequential
           [:tuple int? [:map [:y [:maybe boolean?]]]]]]]]]]
  [:x 0 0 0 0 1 :y 0])
; => boolean?

(malli.util/select-keys
  [:map {:title "map"}
   [:a int?]
   [:b {:optional true} int?]
   [:c string?]]
  [:a ::extra])
;[:map {:title "map"}
; [:a int?]
; [:b {:optional true} int?]]

(-> [:map
     [:a int?]
     [:b string?]
     [:c [:map
          [:x int?]
          [:y keyword?]]]]
    (mu/select-keys [:a :c])
    (mu/update-in [:c] mu/dissoc :y))
;[:map
; [:a int?]
; [:c [:map
;      [:x int?]]]]

LookupSchema
(-get [_ key default] (if (= 0 key) schema default)))

[:vector {:min 0, :max 10} int?]
; =>
{:name :vector
 :properties {:min 0, :max 10}
 :children [int?]}

[:vector {:min 0, :max 10} int?]
; =>
{:type :vector
 :properties {:min 0, :max 10}
 :children [int?]}

(mu/assoc-in nil [:a ::c :d] int?)
; [:map [:a [:map [:b [:map [:c [:map [:d int?]]]]]]]]

(defn update-in
  "Like [[clojure.core/update-in]], but for LensSchemas."
  [schema ks f & args]
  (letfn [(up [s [k & ks] f args]
            (assoc s k (if ks (up (get s k) ks f args)
                              (apply f (get s k) args))))]
    (up schema ks f args)))

(defn update
  "Like [[clojure.core/update]], but for LensSchemas."
  [schema key f & args]
  (let [schema (m/schema schema)]
    (m/-set schema key (apply f (m/-get schema key nil) args))))

(-> [:map [:a [#"^[0-9]+$" {:error/message "should match"}]]]
    (mc/explain {:a "aaa"})
    (me/humanize))

[:map [:a [:re {:error/message "should match"} #"^[0-9]+$"]]]

["/paginated/:table"
 {:get {:coercion reitit.coercion.malli/coercion
        :parameters {:path {:table string?}
                     :query {:page int?
                             :page-size int?}}
        :responses {200 {:body any?}}
        :handler (fn [{:keys [path-params params] :as req}]
                   {:status 200
                    :body "OK"})}}]

(http/router routes {:data {:middleware [rrc/coerce-exceptions-middleware
                                         rrc/coerce-request-middleware
                                         rrc/coerce-response-middleware]}})

{:parameters {:query {{:page 1}}}

{:table string?} --> [:map [:table string?]]

:parameters {:path [:map
                               [:table string?]]
                        :query [:map
                                [:page int?]
                                [:page-size int?]]}

["/math"
        {:swagger {:tags ["math"]}}

        ["/plus"
         {:get {:summary "plus with malli query parameters"
                :parameters {:query [:map [:x int?] [:y int?]]}
                :responses {200 {:body [:map [:total int?]]}}
                :handler (fn [{{{:keys [x y]} :query} :parameters}]
                           {:status 200
                            :body {:total (+ x y)}})}
          :post {:summary "plus with malli body parameters"
                 :parameters {:body [:map [:x int?] [:y int?]]}
                 :responses {200 {:body [:map [:total int?]]}}
                 :handler (fn [{{{:keys [x y]} :body} :parameters}]
                            {:status 200
                             :body {:total (+ x y)}})}}]]]

(m/valid?
  [:cat
   [:x int?]
   [:y int?]
   [:rest [:* string?]]]
  [1 2 "kikka" "kukka"])
; => true

(m/destructure
  [:cat
   [:x int?]
   [:y int?]
   [:rest [:* string?]]]
  [1 2 "kikka" "kukka"])
; {:x 1
;  :y 2
;  :rest ("kikka "kukka")}

(m/valid?
  [:cat int? int? [:* string?]]
  [1 2 "kikka" "kukka"])
; => true

(require '[net.cgrand.seqexp :as se])

(se/exec
  (se/cat
    (se/as :x int?)
    (se/as :y int?)
    (se/as :restz (se/* :string?)))
  [1 2 "kikka" "kukka"])
;{:x (1)
; :y (2)
; :restz ("kikka" "kukka")
; :rest ()}

;; 40ns
(let [spec (s/and int? (s/or :pos-int pos-int? :neg-int neg-int?))
      valid? (partial s/valid? spec)]
  (cc/quick-bench
    (valid? 0)))

;; 5ns
(let [valid? (m/validator [:and int? [:or pos-int? neg-int?]])]
  (cc/quick-bench
    (valid? 0)))

(require '[malli.core :as m])
(require '[malli.transform :as mt])

(def transformer
  (mt/transformer
    ;; first run schema-based transformations named :before
    {:name :before}
    ;; run json-things
    (mt/json-transformer)
    ;; add default values
    (mt/default-value-transformer)
    ;; run custom things
    {:name :after}))

(m/decoder
  [:map
   [:name string?]
   [:age int?]
   [:address
    [:map
     [:street string?]
     [:country [:enum "finland" "germany"]]]]]
  transformer)
; => clojure.core$identity

(def Schema
  [:map
   [:a [:or pos-int? string?]]
   [:b string?]])

(m/explain Schema {:a 42, :"a"})
;{:schema [:map
;          [:a [:or pos-int? string?]]
;          [:b string?]]
; :value {:a 42, :"a"},
; :results [#Success{:path [1 1 1], :in [:a], :schema pos-int?, :value 42}
;           #Success{:path [2 1], :in [:b], :schema string?, :value "a"}]}

(-> Schema
    (m/explain {:a 42 :b "a"})
    (me/humanize))
;{:a #Branch{1 42}
; :b "a"}

{:args [{:op :keys
         :req {:a {:op :keys
                   :req {:b {:op :keys
                             :req {:c :int}}}}}}]
 :ret {:op :keys
       :req {:b {:op :keys
                 :req {:c :int}}}}}

(def mumap
  [:multi {:dispatch :db/shared-channel}
   ["folder" [:map [:db/shared-channel string?] [:db/shared-channel-folder string?]]]
   ["web" [:map [:db/shared-channel string?] [:db/shared-channel-url string?]]]])

[:map [:db/shared-channel [:= "folder"]] [:db/shared-channel-folder string?]]

(def sample1 {:db/type                  "h2",
              :h2/user                  "sa",
              :h2/filename              "./boxdb",

              :db/shared-channel        "folder",
              :db/shared-channel-folder "dev/resources/shared"})

(def sample2 {:db/type               "h2",
              :h2/user               "sa",
              :h2/filename           "./boxdb",

              :db/shared-channel     "web",
              :db/shared-channel-url ""})

(def mumap
  [:multi {:dispatch :db/shared-channel}
   ["folder" [:map [:db/shared-channel [:= "folder"]] [:db/shared-channel-folder string?]
              [:db/type [:and string? [:fn {:error/message "should not be empty string"} not-empty-string?]]]
              [:h2/filename {:default "./boxdb"} string?]
              [:h2/user {:default "sa"} string?]]]
   ["web" [:map [:db/shared-channel [:= "web"]] [:db/shared-channel-url string?]
           [:db/type [:and string? [:fn {:error/message "should not be empty string"} not-empty-string?]]]
           [:h2/filename {:default "./boxdb"} string?]
           [:h2/user {:default "sa"} string?]]]])

[:map
 [:db/type [:and string? [:fn {:error/message "should not be empty string"} not-empty-string?]]]
 [:h2/filename {:default "./boxdb"} string?]
 [:h2/user {:default "sa"} string?]
 [:multi {:dispatch :db/shared-channel}
  ["folder" [:map [:db/shared-channel [:= "folder"]] [:db/shared-channel-folder string?]]]
  ["web" [:map [:db/shared-channel [:= "web"]] [:db/shared-channel-web string?]]]]]

(def BaseMap
  [:map
   [:db/type [:and string? [:fn {:error/message "should not be empty string"} not-empty-string?]]]
   [:h2/filename {:default "./boxdb"} string?]
   [:h2/user {:default "sa"} string?]])

(def Multi
  [:multi {:dispatch :db/shared-channel}
    ["folder" (mu/merge BaseMap [:map [:db/shared-channel [:= "folder"]] [:db/shared-channel-folder string?]])]
    ["web" (mu/merge BaseMap [:map [:db/shared-channel [:= "web"]] [:db/shared-channel-web string?]]])]])

{:some-date #inst "2020-02-02"}

(require '[malli.provider :as mp])

(mp/provide [{:some-date #inst "2020-02-02"}])
; => [:map [:some-date inst?]]

(def registry
  (merge
    default-registry
    {:cat (cat-schema :cat)
     :| (cat-schema :|)
     :* (regex-schema :* se/*)
     :*? (regex-schema : se/*?)
     :+ (regex-schema :+ se/+)
     :+? (regex-schema :+? se/+?)
     :? (regex-schema :? se/?)
     :?? (regex-schema :?? se/??)
     :repeat (regex-schema :repeat? se/repeat)
     :repeat? (regex-schema :repeat? se/repeat?)}))

(require '[net.cgrand.seqexp :as se])

(se/exec
  (se/cat
    (se/as :x int?)
    (se/as :y int?)
    (se/as :rest2 (se/* string?)))
  [1 2 "kikka" "kukka"])
; {:rest (), :match (1 2 "kikka" "kukka"), :x (1), :y (2), :rest2 ("kikka" "kukka")}

[:cat
 [:x int?]
 [:y int?]
 [:rest [:* string?]]]

(se/exec-tree
  (se/cat
    (se/*
      (se/as [:opts]
             (se/cat
               (se/as [:opts :x] string?)
               (se/| (se/as [:opts :s] string?) (se/as [:opts :b] boolean?))))))
  ["-server" "foo" "-verbose" true "-user" "joe"])

(se/exec
  (se/cat
    (se/as :x (se/repeat 1 int?))
    (se/as :y int?)
    (se/as :restz (se/* string?)))
  [1 2 "kikka" "kukka"])
; {:rest (), :match (1 2 "kikka" "kukka"), :x (1), :y (2)}

(se/*
  (se/as [:sections]
         (se/cat :h1
                 (se/as [:sections :ps]
                        (se/+ :p)))))

(mp/provide {:some-date #inst "2020-02-02"})
;; => [:vector some?]

com.github.metosin/malli {:git/url ""
                            :sha "9db4ff998b641d4a0cff4eb6d772fd0cb5d3b56c"}

(seq {:some-date #inst "2020-02-02"})
;; => ([:some-date #inst"2020-02-02T00:00:00.000-00:00"])

;; JVM started with -Dmalli.core.registry=malli.mutable/registry

(require '[malli.core :as m])
(require '[malli.mutable :as mm])

(mm/register! ::age [:and int? [:> 18]])

(m/validate ::age 20)
; => true

;; in my-ns
(defn validate [schema data options]
  (m/validate schema data (assoc options :registry my-registry)))

(->> (with-open [conn (jdbc/get-connection db-datasource)]
         (jdbc.sql/query conn ["select * from myschema.mytable"]))
       (malli.provider/provide))
  [:map
   [:mytable/id int?]
   [:mytable/name string?]]

(require '[malli.util :as mu])
(mu/get-in [:map [keyword? int?]] [:a])
;=> returns nil, but I expected int?

(m/validate [:map [keyword? int?]] {:a 1})
; => false

(m/validate [:map [keyword? int?]] {keyword? 1})
; => true

=> (mu/get-in [:map-of keyword? int?] [:a])
Execution error (IllegalArgumentException) at malli.core/fn$G (core.cljc:26).
No implementation of method: :-get of protocol: #'malli.core/LensSchema found for class: malli.core$_map_of_schema$reify$reify__692

(-get [_ key default] (if (key-valid? key) value-schema default))

(mu/assoc [:map-of keyword? int?] :foo boolean?)
;=> should probably create
[:or
 [:map [:foo boolean?]]
 [:map-of keyword? int?]]

[:cat [:a int?] [:b :string?]]              ;; matches '(1 "a") and [1 "a"]
[:in-list [:cat [:a int?] [:b :string?]]]   ;; matches '(1 "a")
[:in-vector [:cat [:a int?] [:b :string?]]] ;; matches '[1 "a"]

[:or
 {:error/message "nil, string, or int"}
 nil?
 string?
 int?]

[:string {:min 1, :max 10}]
[:int {:min 1, :max 10}]
[:date {:min "2012-04-23"}]
[:date-time {:min "2012-04-23 00:00:00", :format "yyyy-MM-dd HH:mm:ss"}] 

"Malli is a schema system for JSON."

"This JSON:"

{"x": 1,
 "name": "something"}

"Gets this schema:"

[:map
 [:x int?]
 [:name string?]]

(def metadata-schema
  [:map {:postgres/schema "slm"
         :postgres/table "measurement_metadatas"}
   [:id {:postgres/type :bigserial
         :postgres/key  :primary} int?]
   [:instrument-id {:postgres/type :bigint
                    :postgres/null? false} int?]
   [:datafile-id   {:postgres/type :bigint
                    :postgres/null? false} int?]
   [:seq           {:postgres/type :integer
                    :postgres/null? false} int?]
   [:origin        {:postgres/type :float8
                    :postgres/null? false} double?]
   [:scale         {:postgres/type :float4
                    :postgres/null? false} float?]
   [:starting-timestamp {:postgres/type :timestamptz
                         :postgres/null? false} inst?] ;; TODO: fix
   [:sample-rate   {:postgres/type :float4
                    :postgres/null? false} float?]
   [:log-interval  {:postgres/type :float4
                    :postgres/null? false} float?]
   [:weighting     {:postgres/type :text
                    :postgres/null? false} string?]
   [:manifest      {:postgres/type :int
                    :postgres/null? false} int?]
   [:time-zone     {:postgres/type :int
                    :postgres/null? false} int?]])

CREATE TABLE slm.measurement_metadatas (
    id bigserial PRIMARY KEY,
    instrument_id bigint NOT NULL,
    datafile_id bigint NOT NULL,
    seq integer NOT NULL,
    origin float8 NOT NULL,
    scale float4 NOT NULL,
    starting_timestamp timestamptz NOT NULL,
    sample_rate float4 NOT NULL,
    log_interval float4 NOT NULL,
    weighting text NOT NULL,
    manifest int NOT NULL,
    time_zone int NOT NULL
    );

(def +string-decoders+
  (merge
    +json-decoders+
    {'integer? string->long
     'int? string->long

What is the meaning/use of the :name key in the mt/transformer input map?

{:compile '(fn [schema _]

(defn map-entries
  "Returns a sequence of 3-element map-entry tuples of type `key ?properties schema`"
  ([?schema]
   (map-entries ?schema nil))
  ([?schema options]
   (if-let [schema (schema ?schema options)]
     (if (satisfies? MapSchema schema)
       (-map-entries schema)))))

[:map
 [:x [int? {:decode/postgre ...}]]]

(def my-schema
  (m/schema
   [:map {:closed true
          :encode/postgres csk/->kebab-case-keyword
          :decode/postgres csk/->snake_case_keyword}
    [:id             {:optional true
                      :postgres/type :bigserial
                      :postgres/key  :primary} int?]
    [:instrument-id  {:postgres/type :bigint
                      :postgres/null? false} int?]
    ]
   ))

(def sample
  {:id 12345
   :instrument-id 67890})

(m/decode my-schema sample (mt/key-transformer {:name :postgres}))

;; {:id 12345, :instrument-id 67890}

(def Human
  [:map
   [:human/name {:description "Human name"} string?]
   [:human/age {:description "Human age"} int?]])

(doseq [[k p _] (m/map-entries Human)]
  (println k "->" (-> p :description)))
;:human/name -> Human name
;:human/age -> Human age

(def Human
  [:map
   [:human/name [:and {:description "Human name"} string?]]
   [:human/age  [:and {:description "Human age"} int?]]])

(doseq [[k _ s] (m/map-entries Human)]
  (println k "->" (-> s m/properties :description)))
;:human/name -> Human name
;:human/age -> Human age

(def Human
  [:map
   [:human/name [string? {:description "Human name"}]]
   [:human/age  [int? {:description "Human age"}]]])

(doseq [[k _ s] (m/map-entries Human)]
  (println k "->" (-> s m/properties :description)))
;:human/name -> Human name
;:human/age -> Human age

(malli.json-schema/transform
  [:map
   [:human/name [string? {:description "Human name"}]]
   [:human/age [int? {:description "Human age"}]]])
;{:type "object",
; :properties #:human{:name {:type "string", :description "Human name"},
;                     :age {:type "integer", :format "int64", :description "Human age"}},
; :required [:human/name :human/age]}

[:id {:optional true
        :postgres/type :column
        :postgres/datatype :bigserial
        :postgres/key :primary} int?]

(def my-registry {::id int?})

(m/schema  
  [::id {:optional true
        :postgres/type :column
        :postgres/datatype :bigserial
        :postgres/key :primary}]
{:registry my-registry})

[:id {:optional true
        :postgres/type :column
        :postgres/datatype :bigserial
        :postgres/key :primary} int?]

[:map
   [:Data
    [:map
     [:CommunicationChannels
      [:vector
       [:map
        [:Identifier [:map [:Value string?] [:Details [:map [:ID string?] [:SystemID string?]]]]]
        [:ChannelType [:map [:Type int?] [:Name string?]]]
        [:Content string?]]]]]]]

[:map
   [:Data
    [:map
     [:CommunicationChannels
      [:vector
       [:map
        [:Identifier [:map [:Value string?] [:Details [:map [:ID string?] [:SystemID string?]]]]]
        [:ChannelType [:map [:Type int?]
                       [:or
                        [:Name "EMail"]
                        [:Name "Mobile"]
                        [:Name "Fax"]]]]
        [:Content string?]]]]]]]

user=> (m/validator [:map
  #_=>  [:Data
  #_=>   [:map
  #_=>    [:GroupMemberships [:vector [:or]]]]]])
Execution error (ExceptionInfo) at malli.core/fail! (core.cljc:73).
:malli.core/no-children

[:or
 [:map
  :spritesheet/name
  :spritesheet/frame]
 [:map
  :spritesheet/name
  :spritesheet/animation]]

(def Weighting
  [:enum :dB-A :dB-C :dB-Z])

(def MyMap
  (m/schema
   [:map
    [:weighting Weighting]]))

(defn weighting->kw
  [n]
  (if (int? n)
    (case n
      0 :dB-C
      1 :dB-A
      2 :dB-Z
      n)
    n))

(mt/transformer
 {:name :weighting
  :decoders {:enum weighting->kw}})

[:or
 [:map
  :spritesheet/name
  :spritesheet/frame]
 [:map
  :spritesheet/name
  :spritesheet/animation]]

;Valid:
{:key1 "yo"}

;Also valid
{:nested {:key2 "yo"}}

[:or
 [:map
  [:key1 any?]
  [:nested {:optional true} [:map [:key2 {:optional true} any?]]]]
 [:map
  [:key1 {:optional true} any?]
  [:nested [:map [:key2 any?]]]]]

(def Weighting
  [:enum {:decode/enum weighting->kw} :dB-A :dB-C :dB-Z])

(m/decode MyMap {:weighting 0} (mt/transformer {:name :enum}))
; => {:weighting :dB-C}

(m/validate schema (m/decode
    schema data
    (mt/transformer mt/strip-extra-keys-transformer mt/string-transformer)))))

[:multi
 {:dispatch :type, :decode/string (fn* [p1__40150#] (update p1__40150# :type keyword))}
 [:other [:map [:data [:map [:nombre string?] [:apellido string?] [:edad int?]]] [:type [:= :other]]]]
 [:one [:map [:data [:map [:nombre string?] [:apellido string?] [:kk int?]]] [:type [:= :one]]]]]

{:data {:nombre "nombre" :apellido "apellido" :edad 12} :type "other"}

(def m [:map
          [:i {:error/message "not a number"} int?]])

  (me/humanize (m/explain m {:i "123"}))
  ;; => {:i ["should be int"]}

(def m [:map
          [:i
           [int? {:error/message "not a number"}]]])

(require '[malli.provider])
(malli.provider/provide [[]])
; => [:vector [:or]]

(provide [])
; => any?

(provide [[]])
; => [:vector any?]

(provide [[[[[[[]]]]]]])
; => [:vector [:vector [:vector [:vector [:vector [:vector any?]]]]]]

(s/def ::title string?)
(s/def ::children (s/coll-of ::node))

(s/def ::node
  (s/keys :req-un [::title
                   ::children]))

(def Country
  [:map {:id "Country"}
   [:name [:enum :FI :PO]]
   [:neighbors any?]])

(def Burger
  [:map {:id "Burger"}
   [:name string?]
   [:description {:optional true} string?]
   [:origin [:maybe [:maybe Country]]]
   [:price pos-int?]])

(def OrderLine
  [:map {:id "OrderLine"}
   [:burger Burger]
   [:amount int?]])

(def Order
  [:map {:id "Order"}
   [:lines [:vector OrderLine]]
   [:delivery [:map
               [:delivered boolean?]
               [:address [:map
                          [:street string?]
                          [:zip int?]
                          [:country Country]]]]]])

(require '[malli.mermaid :as mermaid])

(mermaid/class-diagram Order)
;"classDiagram
;   class Country {
;     + :name [:enum :FI :PO]
;     + :neighbors any?
;   }
;   class Burger {
;     + :name string?
;     + :description string?
;     + :origin Country
;     + :price pos-int?
;   }
;   Burger o-- Country
;   class OrderLine {
;     + :burger Burger
;     + :amount int?
;   }
;   OrderLine o-- Burger
;   class OrderDeliveryAddress {
;     <<embedded>>
;     + :street string?
;     + :zip int?
;     + :country Country
;   }
;   OrderDeliveryAddress o-- Country
;   class OrderDelivery {
;     <<embedded>>
;     + :delivered boolean?
;     + :address OrderDeliveryAddress
;   }
;   OrderDelivery *-- OrderDeliveryAddress
;   class Order {
;     + :lines OrderLine
;     + :delivery OrderDelivery
;   }
;   Order o-- OrderLine
;   Order *-- OrderDelivery"

{:type "object",
 :properties {:id {:type "string"},
              :tags {:type "array",
                     :items {:type "string"},
                     :uniqueItems true},
              :address {:type "object",
                        :properties {:street {:type "string"},
                                     :city {:type "string"},
                                     :zip {:type "integer",
                                           :format "int64"},
                                     :lonlat {:type "array",
                                              :items [{:type "number"}
                                                      {:type "number"}],
                                              :additionalItems false}},
                        :required [:street :city :zip :lonlat],
                        :title "Something"}},
 :required [:id :tags :address],
 :title "Address"}

[:identity [:map [:user map?] [:profile map?] [:token  [string? {:deleteMe true}] ]]]]

[:identity [:map [:user map?] [:profile map?]]]]

(m/accept
  [:map
   [:user map?]
   [:profile map?]
   [:nested [:map [:x [:tuple {:deleteMe true} string? string?]]]]
   [:token [string? {:deleteMe true}]]]
  (fn [schema children _ options]
    (if-not (:deleteMe (m/properties schema))
      (let [children (filterv (if (m/map-entries schema) last identity) children)]
        (m/into-schema (m/name schema) (m/properties schema) children options)))))
; => [:map [:user map?] [:profile map?] [:nested :map]]

(def User [:map [:users [:vector [:map [:user string?]]]]])

(m/decode User "<users><user>simo</user></users>" malli.xml/xml-transformer)
; => {:users [{:user "simo"}]}

(m/encode User {:users [{:user "simo"}]} malli.xml/xml-transformer)
; => "<users><user>simo</user></users>"

(defn ->map-syntax
  ([?schema] (->map-syntax ?schema nil))
  ([?schema options] (m/accept ?schema m/map-syntax-visitor options)))

(defn <-map-syntax
  ([m] (<-map-syntax m nil))
  ([{:keys [name properties children]} options]
   (let [<-child (if (-> children first vector?) (fn [f] #(update % 2 f)) identity)]
     (m/into-schema name properties (mapv (<-child #(<-map-syntax % options)) children)))))

(def Schema
  [:map
   [:id string?]
   [:tags [:set keyword?]]
   [:address
    [:vector
     [:map
      [:street string?]
      [:lonlat [:tuple double? double?]]]]]])

(->map-syntax Schema)
;{:name :map,
; :children [[:id nil {:name string?}]
;            [:tags nil {:name :set
;                        :children [{:name keyword?}]}]
;            [:address nil {:name :vector,
;                           :children [{:name :map,
;                                       :children [[:street nil {:name string?}]
;                                                  [:lonlat nil {:name :tuple
;                                                                :children [{:name double?} {:name double?}]}]]}]}]]}

(-> Schema
    (->map-syntax)
    (<-map-syntax))
;[:map
; [:id string?]
; [:tags [:set keyword?]]
; [:address
;  [:vector
;   [:map
;    [:street string?]
;    [:lonlat [:tuple double? double?]]]]]]

(register! :phone [:re
                   {:description "Phone",
                    :phone-prefix-regex phone-prefix-regex
                    :phone-code-regex phone-code-regex
                    :error/fn
                    '(fn [{:keys [value schema]} _]
                       (let [{:keys [phone-prefix-regex
                                     phone-code-regex]} (m/properties schema)
                             has-prefix? (re-find phone-prefix-regex value)
                             has-code? (re-find phone-code-regex value)]
                         (cond
                           (not has-prefix?)
                           :errors/phone-invalid-prefix
                           (not has-code?)
                           :errors/phone-invalid-country-code
                           :else
                           :errors/phone-invalid-number)))}
                   phone-regex])

(defn ^:no-doc eval [?code]
  (if (fn? ?code) ?code (sci/eval-string (str ?code) {:preset :termination-safe
                                                      :bindings {'m/properties properties
                                                                 'm/name name
                                                                 'm/children children
                                                                 'm/map-entries map-entries}})))

(m/validate :string "")
; => true

(m/validate [:string {:min 1}] "")
; => false

(json-schema/transform [:string {:min 1, :max 4}])
; => {:type "string", :minLength 1, :maxLenght 4}

(mg/sample [:string {:min 1, :max 4}])
; => ("RMmR" "5" "oL" "G7" "ENo" "cAh" "iOb" "jG" "l8" "kuo")

(-> [:map
     [:a :string]
     [:b [:string {:min 1}]]
     [:c [:string {:max 4}]]
     [:d [:string {:min 1, :max 4}]]]
    (m/explain
      {:a 123
       :b ""
       :c "invalid"
       :d ""})
    (me/humanize))
;{:a ["should be string"],
; :b ["should be at least 1 characters"],
; :c ["should be at most 4 characters"],
; :d ["should be between 1 and 4 characters"]}

(require '[malli.transform :as mt])
(require '[malli.core :as m])
(require '[clojure.string :as str])

(defn string-trimmer []
  (mt/transformer
    {:decoders
     {:string
      {:compile (fn [schema _]
                  (let [{:string/keys [trim]} (m/properties schema)]
                    (when trim #(cond-> % (string? %) str/trim))))}}}))

(m/decode [:string {:min 1}] "    " string-trimmer)
; => "    "

(m/decode [:string {:string/trim true, :min 1}] "    " string-trimmer)
; => ""

(m/decoder :string string-trimmer)
; => #object[clojure.core$identity] ... no-op! :)